import { BASE_URL } from '@/utils/config'

// 创建装饰记录
export function createRecord(data) {
  if (!data.userId) {
    return Promise.reject(new Error('用户ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用createRecord接口，参数:', data);
    
    uni.request({
      url: `${BASE_URL}/api/decoration/record`,
      method: 'POST',
      data: data,
      success: (res) => {
        console.log('createRecord响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else {
          reject(new Error(res.data.msg || '创建记录失败'));
        }
      },
      fail: (err) => {
        console.error('createRecord请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 将图片转换为base64
async function imageToBase64(imageUrl) {
  return new Promise((resolve, reject) => {
    if (!imageUrl) {
      reject(new Error('图片URL不能为空'));
      return;
    }

    // 如果已经是base64格式，直接返回
    if (imageUrl.startsWith('data:image')) {
      resolve(imageUrl);
      return;
    }

    uni.getFileSystemManager().readFile({
      filePath: imageUrl,
      encoding: 'base64',
      success: (res) => {
        // 根据文件扩展名确定MIME类型
        let mimeType = 'image/jpeg'; // 默认MIME类型
        if (imageUrl.toLowerCase().endsWith('.png')) {
          mimeType = 'image/png';
        } else if (imageUrl.toLowerCase().endsWith('.gif')) {
          mimeType = 'image/gif';
        }
        const base64Data = `data:${mimeType};base64,${res.data}`;
        resolve(base64Data);
      },
      fail: (err) => {
        console.error('读取文件失败:', err);
        reject(new Error('读取图片失败'));
      }
    });
  });
}

// 使用文本生成图片
export function generateFromText(userId, prompt, roomImageUrl = null, roomId = null) {
  if (!userId) {
    return Promise.reject(new Error('用户ID不能为空'));
  }
  if (!prompt) {
    return Promise.reject(new Error('提示词不能为空'));
  }
  
  return new Promise(async (resolve, reject) => {
    console.log('调用generateFromText接口，参数:', { userId, prompt, roomImageUrl, roomId });
    
    try {
      // 构建请求数据
      const requestData = {
        userId,
        prompt,
        roomImageUrl,
        roomId  // 添加roomId到请求数据中
      };

      // 如果是临时文件URL，转换为base64
      if (roomImageUrl && (roomImageUrl.startsWith('http://tmp/') || roomImageUrl.startsWith('wxfile://'))) {
        try {
          const base64Data = await imageToBase64(roomImageUrl);
          if (base64Data) {
            requestData.imageData = base64Data.split(',')[1]; // 移除base64头
            console.log('图片转换为base64成功');
          }
        } catch (err) {
          console.error('图片转base64失败:', err);
          reject(new Error('图片处理失败，请重试'));
          return;
        }
      }
      // 如果已经是base64格式，直接使用
      else if (roomImageUrl && roomImageUrl.startsWith('data:image')) {
        requestData.imageData = roomImageUrl.split(',')[1];
      }

      uni.request({
        url: `${BASE_URL}/api/decoration/generateFromText`,
        method: 'POST',
        data: requestData,
        header: {
          'content-type': 'application/json'
        },
        timeout: 90000, // 90秒超时
        success: (res) => {
          console.log('generateFromText响应:', res);
          
          if (res.statusCode === 200) {
            if (res.data && res.data.code === 200 && res.data.data) {
              // 确保返回的图片URL是完整的
              let imageUrl = res.data.data;
              if (!imageUrl.startsWith('http')) {
                imageUrl = `${BASE_URL}${imageUrl.startsWith('/') ? '' : '/'}${imageUrl}`;
              }
              console.log('成功获取图片URL:', imageUrl);
              resolve(imageUrl);
            } else {
              let errorMsg = res.data?.message || res.data?.msg || '生成失败';
              
              // 处理特定的错误情况
              if (errorMsg.includes('SignatureDoesNotMatch') || errorMsg.includes('signature')) {
                errorMsg = '服务器临时访问受限，请稍后重试';
              } else if (errorMsg.includes('download')) {
                errorMsg = '图片下载失败，请重试';
              } else if (errorMsg.includes('timeout')) {
                errorMsg = '生成超时，请重试';
              } else if (errorMsg.includes('base64')) {
                errorMsg = '图片格式不正确，请重新选择';
              } else if (errorMsg.includes('临时文件')) {
                errorMsg = '图片格式不支持，请重新选择';
              }
              
              console.error('业务错误:', errorMsg, res.data);
              reject(new Error(errorMsg));
            }
          } else {
            console.error('HTTP错误:', res.statusCode);
            reject(new Error(`网络请求失败(${res.statusCode})，请稍后重试`));
          }
        },
        fail: (err) => {
          console.error('generateFromText请求失败:', err);
          reject(new Error('网络请求失败，请检查网络连接'));
        }
      });
    } catch (err) {
      console.error('处理请求时发生错误:', err);
      reject(new Error('请求处理失败，请重试'));
    }
  });
}

// 查询任务状态
export function queryTaskStatus(taskId) {
  if (!taskId) {
    return Promise.reject(new Error('任务ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('查询任务状态，任务ID:', taskId);
    
    uni.request({
      url: `${BASE_URL}/api/decoration/queryTask/${taskId}`,
      method: 'GET',
      timeout: 10000,
      success: (res) => {
        console.log('queryTaskStatus响应:', res);
        
        if (res.statusCode === 200) {
          if (res.data && res.data.code === 200) {
            const taskStatus = res.data.data?.status || 'unknown';
            console.log('任务状态:', taskStatus);
            
            if (taskStatus === 'completed' && res.data.data?.imageUrl) {
              resolve({
                status: 'completed',
                imageUrl: res.data.data.imageUrl
              });
            } else if (taskStatus === 'processing') {
              resolve({
                status: 'processing',
                progress: res.data.data?.progress || 0,
                message: res.data.data?.message || '正在生成图片...'
              });
            } else if (taskStatus === 'failed') {
              reject(new Error(res.data.data?.errorMessage || '图片生成失败'));
            } else {
              resolve({
                status: 'unknown',
                message: '任务状态未知，请稍后查询'
              });
            }
          } else {
            const errorMsg = res.data?.message || res.data?.msg || '查询任务状态失败';
            console.error('查询任务状态业务错误:', errorMsg);
            reject(new Error(errorMsg));
          }
        } else {
          console.error('查询任务状态HTTP错误:', res.statusCode);
          reject(new Error(`查询任务状态失败: ${res.statusCode}`));
        }
      },
      fail: (err) => {
        console.error('查询任务状态请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 使用图片生成图片
export function generateFromImage(file, userId, prompt) {
  if (!userId) {
    return Promise.reject(new Error('用户ID不能为空'));
  }
  if (!file) {
    return Promise.reject(new Error('图片文件不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用generateFromImage接口，参数:', { userId, prompt });
    
    uni.uploadFile({
      url: `${BASE_URL}/api/decoration/generateFromImage`,
      filePath: file,
      name: 'file',
      formData: {
        userId: userId,
        prompt: prompt || ''
      },
      timeout: 90000, // 90秒超时
      success: (res) => {
        console.log('generateFromImage响应:', res);
        try {
          let responseData;
          if (typeof res.data === 'string') {
            responseData = JSON.parse(res.data);
          } else {
            responseData = res.data;
          }
          
          if (res.statusCode === 200 && responseData.code === 200) {
            let imageUrl = responseData.data;
            if (!imageUrl.startsWith('http')) {
              imageUrl = `${BASE_URL}${imageUrl.startsWith('/') ? '' : '/'}${imageUrl}`;
            }
            console.log('成功获取生成的图片URL:', imageUrl);
            resolve(imageUrl);
          } else {
            const errorMsg = responseData.message || responseData.msg || '生成失败，请重试';
            console.error('业务错误:', errorMsg);
            reject(new Error(errorMsg));
          }
        } catch (error) {
          console.error('解析响应数据失败:', error);
          reject(new Error('解析响应数据失败，请重试'));
        }
      },
      fail: (err) => {
        console.error('generateFromImage请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 获取装饰记录列表
export function getRecords(userId, pageNum = 1, pageSize = 10) {
  if (!userId) {
    return Promise.reject(new Error('用户ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用getRecords接口，参数:', { userId, pageNum, pageSize });
    
    uni.request({
      url: `${BASE_URL}/api/decoration/record`,
      method: 'GET',
      data: {
        userId,
        pageNum,
        pageSize
      },
      success: (res) => {
        console.log('getRecords响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else {
          reject(new Error(res.data.msg || '获取记录列表失败'));
        }
      },
      fail: (err) => {
        console.error('getRecords请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 获取装饰记录详情
export function getRecordDetail(id) {
  if (!id) {
    return Promise.reject(new Error('记录ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用getRecordDetail接口，参数:', { id });
    
    uni.request({
      url: `${BASE_URL}/api/decoration/record/${id}`,
      method: 'GET',
      success: (res) => {
        console.log('getRecordDetail响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else {
          reject(new Error(res.data.msg || '获取记录详情失败'));
        }
      },
      fail: (err) => {
        console.error('getRecordDetail请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 更新装饰记录
export function updateRecord(id, data) {
  if (!id) {
    return Promise.reject(new Error('记录ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用updateRecord接口，参数:', { id, data });
    
    uni.request({
      url: `${BASE_URL}/api/decoration/record/${id}`,
      method: 'PUT',
      data: data,
      success: (res) => {
        console.log('updateRecord响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else {
          reject(new Error(res.data.msg || '更新记录失败'));
        }
      },
      fail: (err) => {
        console.error('updateRecord请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 删除装饰记录
export function deleteRecord(id) {
  if (!id) {
    return Promise.reject(new Error('记录ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用deleteRecord接口，参数:', { id });
    
    uni.request({
      url: `${BASE_URL}/api/decoration/record/${id}`,
      method: 'DELETE',
      success: (res) => {
        console.log('deleteRecord响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve();
        } else {
          reject(new Error(res.data.msg || '删除记录失败'));
        }
      },
      fail: (err) => {
        console.error('deleteRecord请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 生成预览图
export function generatePreview(record) {
  if (!record.id) {
    return Promise.reject(new Error('记录ID不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用generatePreview接口，参数:', record);
    
    uni.request({
      url: `${BASE_URL}/api/decoration/preview`,
      method: 'POST',
      data: record,
      success: (res) => {
        console.log('generatePreview响应:', res);
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data.data);
        } else {
          reject(new Error(res.data.msg || '生成预览图失败'));
        }
      },
      fail: (err) => {
        console.error('generatePreview请求失败:', err);
        reject(new Error('网络请求失败，请检查网络连接'));
      }
    });
  });
}

// 获取用户的装饰记录列表
export function listRecordsByUserId(userId) {
  return new Promise((resolve, reject) => {
    if (!userId) {
      reject(new Error('用户ID不能为空'));
      return;
    }
    
    uni.request({
      url: `${BASE_URL}/api/decoration/user/${userId}`,
      method: 'GET',
      success: (res) => {
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data);
        } else {
          reject(new Error(res.data?.msg || '获取记录列表失败'));
        }
      },
      fail: (err) => {
        console.error('获取记录列表失败:', err);
        reject(new Error('网络请求失败，请重试'));
      }
    });
  });
}

// 分页查询用户的装饰记录
export function getUserRecords(params) {
  return new Promise((resolve, reject) => {
    if (!params.userId) {
      reject(new Error('用户ID不能为空'));
      return;
    }
    
    uni.request({
      url: `${BASE_URL}/api/decoration/list`,
      method: 'GET',
      data: {
        userId: params.userId,
        page: params.page || 1,
        pageSize: params.pageSize || 10
      },
      success: (res) => {
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data);
        } else {
          reject(new Error(res.data?.msg || '获取记录列表失败'));
        }
      },
      fail: (err) => {
        console.error('获取记录列表失败:', err);
        reject(new Error('网络请求失败，请重试'));
      }
    });
  });
}

// 更新装饰画记录状态
export function updateStatus(id, status, errorMessage) {
  return new Promise((resolve, reject) => {
    if (!id) {
      reject(new Error('记录ID不能为空'));
      return;
    }
    
    uni.request({
      url: `${BASE_URL}/api/decoration/status/${id}`,
      method: 'PUT',
      data: { status, errorMessage },
      success: (res) => {
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data);
        } else {
          reject(new Error(res.data?.msg || '更新状态失败'));
        }
      },
      fail: (err) => {
        console.error('更新状态失败:', err);
        reject(new Error('网络请求失败，请重试'));
      }
    });
  });
}

// 获取用户最新的装饰记录
export function getLatestRecords(userId, limit = 5) {
  return new Promise((resolve, reject) => {
    if (!userId) {
      reject(new Error('用户ID不能为空'));
      return;
    }
    
    uni.request({
      url: `${BASE_URL}/api/decoration/latest/${userId}`,
      method: 'GET',
      data: { limit },
      success: (res) => {
        if (res.statusCode === 200 && res.data.code === 200) {
          resolve(res.data);
        } else {
          reject(new Error(res.data?.msg || '获取最新记录失败'));
        }
      },
      fail: (err) => {
        console.error('获取最新记录失败:', err);
        reject(new Error('网络请求失败，请重试'));
      }
    });
  });
}

// 使用AI生成装饰画（基于图片）
export function generateDecorationImage(file, userId, prompt) {
  if (!userId) {
    return Promise.reject(new Error('用户ID不能为空'));
  }
  if (!file) {
    return Promise.reject(new Error('图片文件不能为空'));
  }
  
  return new Promise((resolve, reject) => {
    console.log('调用generateDecorationImage接口，参数:', { userId, prompt });
    
    const formData = new FormData();
    formData.append('file', file);
    formData.append('userId', userId);
    if (prompt) {
      formData.append('prompt', prompt);
    }
    
    uni.uploadFile({
      url: `${BASE_URL}/api/decoration/generate/image`,
      filePath: file,
      name: 'file',
      formData: {
        userId,
        prompt
      },
      success: (res) => {
        console.log('generateDecorationImage响应:', res);
        try {
          const data = JSON.parse(res.data);
          if (data.code === 200) {
            resolve(data.data);
          } else {
            reject(new Error(data.msg || '生成失败，请重试'));
          }
        } catch (error) {
          console.error('解析响应数据失败:', error);
          reject(new Error('解析响应数据失败'));
        }
      },
      fail: (err) => {
        console.error('generateDecorationImage请求失败:', err);
        reject(new Error('上传失败，请检查网络连接'));
      }
    });
  });
} 